Selectively enabling runtime editing of an application

ABSTRACT

A method includes receiving credentials at a computing device. The credentials are evaluated to determine whether a user associated with the credentials is authorized to edit an application while the application is being executed. Upon determining that the user is authorized, an editing control is enabled. The editing control is associated with a graphical user interface (GUI) element of the application and is operable to update the GUI element during execution of the application.

CLAIM OF PRIORITY

The present application claims priority from and is a continuationapplication of U.S. patent application Ser. No. 12/975,398, filed onDec. 22, 2010 and entitled “SELECTIVELY ENABLING RUNTIME EDITING OF ANAPPLICATION,” the contents of which are expressly incorporated herein byreference in their entirety.

BACKGROUND

Although the source code for a software application may be text-based,the software application may generate graphic elements during runtime.When developing such applications, it may be difficult to visualize howincremental changes to the source code will change the graphic elements.Some development environments may use a “split view” to simultaneouslydisplay source code and graphics. For example, half of a developmentinterface may display source code while the other half of the interfacepreviews the runtime interface (e.g., displays a preview of a web pageof a web application). However, as design elements such as cascadingstyle sheets (CSS) become complicated, the preview may not accuratelyreflect the interface. Moreover, since the preview may not be completelyaccurate, a software developer may need to context switch between thedevelopment environment and a browser to see what the application (e.g.,web application) will look like.

Another approach is to use placeholder images that attempt to simulatethe appearance of web pages. For example, an online form designer mayuse placeholder images. When a developer adds a text field into theform, the form designer may not actually add a text field capable oftext input into the form. Instead, the form designer may add an imagethat is representative of a text field into the form. The accuracy ofthis approach may depend on the complexity of the web application. Forexample, as long as the developer uses conventional items for which theform designer has accurate placeholder images, the preview may besufficiently accurate. However, if the developer attempts to usecustomized CSS or specialized widgets, the preview may no longer beaccurate or useful. Thus, the user may be forced to context switchbetween a design-time tool, such as the form designer, and a runtimetool, such as a browser.

SUMMARY

Systems and methods of selectively enabling an ability to editapplications during runtime are disclosed. As an example, a methodincludes receiving credentials at a computing device. The credentialsare evaluated to determine whether a user associated with thecredentials is authorized to edit an application while the applicationis being executed. Upon determining that the user is authorized, anediting control is enabled. The editing control is associated with agraphical user interface (GUI) element of the application and isoperable to update the GUI element during execution of the application.

This Summary is provided to introduce a selection of concepts in asimplified form that are further described below in the DetailedDescription. This Summary is not intended to identify key features oressential features of the claimed subject matter, nor is it intended tobe used to limit the scope of the claimed subject matter.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a diagram to illustrate a particular embodiment of a systemoperable to selectively enable runtime editing of an application;

FIG. 2 is a diagram to illustrate a particular embodiment of anapplication that supports runtime editing;

FIG. 3 is a diagram to illustrate a particular embodiment of a method ofselectively enabling runtime editing of an application; and

FIG. 4 is a block diagram of a computing environment including acomputing device operable to support embodiments of computer-implementedmethods, computer program products, and system components as illustratedin FIGS. 1-3.

DETAILED DESCRIPTION

The disclosed techniques may enable selective editing of an applicationwhile the application is being executed. For example, a web applicationmay include an edit mode runtime extension layered over the applicationruntime. The edit mode runtime extension may be enabled or disabled fora user based on credentials provided by the user. When the user isauthorized to make runtime edits to the application, the application maydisplay editing controls for various graphical user interface (GUI)elements. The user may edit the GUI elements via the editing controls.Runtime edits may automatically be reflected in the application withoutthe user having to recompile or restart the application. In addition,the runtime edits may cause modification of underlying application files(e.g., HTML files and CSS files).

In a particular embodiment, a computer-implemented method includesreceiving credentials during execution of an application at a computingdevice. The method also includes evaluating the credentials to determinewhether a user associated with the credentials is authorized to edit theapplication while the application is being executed. The method furtherincludes, upon determining that the user is authorized, enabling anediting control during the execution of the application. The editingcontrol is associated with a graphical user interface (GUI) element ofthe application and is operable to update the GUI element duringexecution of the application.

In another particular embodiment, a non-transitory computer-readablestorage medium includes instructions that, when executed by a computer,cause the computer to receive credentials during execution of anapplication. The instructions are also executable to evaluate thecredentials to determine whether a user associated with the credentialsis authorized to edit the application while the application is beingexecuted. The instructions are further executable to enable an editingcontrol associated with a GUI element of the application upondetermining that the user is authorized. The instructions are executableto modify one or more files of the application based on the input and toupdate the GUI element during the execution of the application toreflect the input.

In another particular embodiment, a computer system includes a processorand a memory storing instructions executable by the processor to receivecredentials during execution of an application. The instructions arealso executable to evaluate the credentials to determine whether a userassociated with the credentials is authorized to edit the applicationwhile the application is being executed. The instructions are furtherexecutable to, upon determining that the user is authorized, enable anediting control associated with a GUI element of the application. Theinstructions are executable to receive input via the editing control andto modify one or more files of the application based on the editinginput. The instructions are also executable to update the GUI elementduring the execution of the application to reflect the input.

FIG. 1 is a diagram to illustrate a particular embodiment of a system100 operable to selectively enable runtime editing of an application.The application may include an application runtime 104 and an edit moderuntime extension 106. The application may also be associated with oneor more application files 102. In a particular embodiment, theapplication is a web application and the computer system 100 is apersonal computing device executing the web application (e.g., via abrowser) or a computer server (e.g., a web server or an applicationserver).

The application files 102 may include files that are used to build andexecute the application. For example, the application files 102 mayinclude hypertext markup language (HTML) files, cascading style sheets(CSS) files, extensible markup language (XML) files, source code files,data files, or any combination thereof.

The system 100 may selectively enable and disable editing controls atthe application. For example, whether or not a particular editingcontrol is enabled and displayed may depend on the identity of the userexecuting the application. To illustrate, editing controls may beselectively enabled and disabled for three users 111, 112, and 113. Eachuser 111-113 may be associated with different credentials (e.g., a username, a password, or a certificate), and the system 100 may selectivelyenable and disable editing controls based on the credentials.

For example, the first user 111 may be associated with read-onlycredentials 121. Thus, the first user 111 may have a read-onlypermission level with respect to the application and may not beauthorized to edit any part of the application while the application isexecuting. When a user with read-only permission executes theapplication, all editing controls at the application may be disabled. Toillustrate, the first user 111 may provide the read-only credentials 121to the system 100 (e.g., via an input device such as a keyboard or amouse). The system 100 may evaluate the read-only credentials 121 anddetermine that the first user 111 is not authorized to edit theapplication while the application is executing. In response, the system100 may disable the edit mode runtime extension 106 and provide a firstGUI 131 to the first user 111 (e.g., by transmitting the first GUI 131to a display device associated with the first user 111). For example, asillustrated in FIG. 1, the first GUI 131 may be a form that includes aplurality of GUI elements, including four text fields and two buttons.The first GUI may not include any editing controls for the GUI elements,since the first user 111 is not authorized to make runtime edits to theapplication.

As another example, the second user 112 may be associated withread-write data credentials 122. Thus, the second user 112 may have aread-write data permission level that authorizes the second user 112 toedit data of the application (but not to edit functionality of theapplication). When a user with read-write data permission executes theapplication, a subset of editing controls at the application may beenabled. To illustrate, the second user 112 may provide the read-writedata credentials 122 to the system 100 (e.g., via an input device suchas a keyboard or a mouse). The system 100 may evaluate the read-writedata credentials 122 and determine that the second user 112 isauthorized to edit data portions of the application while theapplication is executing. In response, the system 100 may enable theedit mode runtime extension 106 and provide a second GUI 132 to thesecond user 112. For example, as illustrated in FIG. 1, an editingcontrol 141 (depicted as a pencil) may be enabled and displayed for dataelements of the form, such as the four text fields. The second user 112may use the editing control 141 for a text field to provide input thatmodifies the properties of the text field, such as layout properties(e.g., corresponding to CSS files) or behavior properties (e.g.,corresponding to HTML files and web script code). For example, thelayout properties for a GUI element may include a background color, aforeground color, a font, a font size, and a location of the GUIelement. Behavior properties for a GUI element may include a data type,a minimum value, a maximum value, or a data validation rule. The seconduser 112 may change any or all of the layout properties and behaviorproperties of the text fields of the second GUI 132.

As yet another example, the third user 113 may be associated withread-write application credentials 123. Thus, the third user 113 may beauthorized to edit any aspect of the application while the applicationis executing, including data and functionality of the application. Whena user with read-write application permission executes the application,all editing controls at the application may be enabled. To illustrate,the third user 113 may provide the read-write application credentials123 to the system 100 (e.g., via an input device such as a keyboard or amouse). The system 100 may evaluate the read-write applicationcredentials 123 and determine that the third user 113 is authorized toedit any part of the application while the application is executing. Inresponse, the system 100 may enable the edit mode runtime extension 106and provide a third GUI 133 to the third user 113. For example, asillustrated in FIG. 1, editing controls may be enabled and displayed forthe text fields of the third GUI 133. Editing controls may also bedisplayed for the form itself, such as an editing control 142 to modifythe form and a delete control 143 to delete the form. For example, theediting control 142 may enable the third user 113 to change layoutproperties (e.g., colors and fonts) of the form and behavior properties(e.g., data validation rules) of the form.

In a particular embodiment, the system 100 may automatically modify theunderlying application files 102 based on input received via the editingcontrols 141-143. For example, source code may automatically begenerated to implement the modifications. The system 100 may alsoautomatically update the GUI elements corresponding to the editingcontrols 141-143. For example, the editing controls 141-143 may beoperable to update the form, the text fields, and the application files102 associated with the form and the text fields.

It will be appreciated that the system 100 of FIG. 1 may selectivelyenable runtime editing of an application and may enable runtime edits tobe made and accurately reflected via a single mode (e.g., a run mode).Therefore, a developer may use the system 100 of FIG. 1 to edit a webapplication in run mode while the web application is executing, withoutcontext switching between the run mode and a separate edit mode. Thesystem 100 of FIG. 1 may advantageously transform an application'sruntime into an editing and development environment, and developers maycreate and update application features from within the runtime.

It should be noted that although the embodiment of FIG. 1 is describedwith reference to a web application and a form, this is for illustrativepurposes only. The runtime editing techniques disclosed herein may beused with any type of application. For example, the disclosed systemsand methods may also be used in a database application. Read-only userssuch as consumers or testers may not be authorized to edit any part ofthe application or the underlying database tables. Read-write data usersmay be able to edit the database tables that are used by theapplication. Read-write application users may be able to edit both theapplication as well as the underlying database tables.

FIG. 2 is a diagram to illustrate a particular embodiment of anapplication 200 that supports runtime editing. The application 200 mayinclude an application runtime 210 and an edit mode runtime extension220. In an illustrative embodiment, the application runtime 210 may bethe application runtime 104 of FIG. 1 and the edit mode runtimeextension 220 may be the edit mode runtime extension 106 of FIG. 1.

In a particular embodiment, the application runtime 210 includes one ormore layers that include runtime code and data. For example, theapplication runtime 210 may include a CSS layer 211, an HTML layer, anda run mode layer 213. The edit mode runtime extension 220 may beconsidered as a layer that may be applied on top of the applicationruntime 210. As described with reference to the edit mode runtimeextension 106 of FIG. 1, the edit mode runtime extension 220 mayselectively be enabled and disabled. When the edit mode runtimeextension 220 is enabled, the application 200 may execute the edit moderuntime extension 220 in conjunction with the run mode layer 213. Thefunctionality of the edit mode runtime extension 220 (e.g., editingcontrols) may be available to users via the run mode layer 213 withoutcontext switching between the run mode layer 213 and a different mode(e.g., a developer edit mode).

It will be appreciated that the application 200 of FIG. 2 may separateCSS, HTML, runtime code, and edit mode code into distinct layers. Forexample, at the CSS level, editing controls (e.g., resize handles,selection boxes, properties, and menus) may be separated by a pseudonamespace. At the HTML level, the code for the editing controls may befully encapsulated so that changes to the editing controls do not affectthe runtime, though changes made via the editing controls do affect theruntime. For example, the editing controls may have a unique prefix orclass name that enables the editing controls to be enabled and disabledwithout modifying any other aspect of the application. The application200 of FIG. 2 may thus be preferable to existing “split-view”environments that combine runtime code and edit mode code.

FIG. 3 is a diagram to illustrate a particular embodiment of a method300 of selectively enabling runtime editing of an application. In anillustrative embodiment, the method 300 may be performed at the system100 of FIG. 1.

The method 300 may include receiving credentials during execution of anapplication, at 302. For example, in FIG. 1, the read-only credentials121, the read-write data credentials 122, or the read-write applicationcredentials 123 may be received.

The method 300 may also include evaluating the credentials, at 304, todetermine whether a user associated with the credentials is authorizedto edit the application while the application is being executed, at 306.For example, in FIG. 1, the credentials 121, 122, or 123 may beevaluated.

When the user is not authorized to edit the application while theapplication is executing, the method 300 may disable editing controls atthe application, at 308. For example, in FIG. 1, the edit mode runtimeextension 106 may be disabled and the first GUI 131 may be provided tothe first user 111.

When the user is authorized to edit the application while theapplication is executing, the method 300 may include enabling an editingcontrol associated with a GUI element of the application, at 310. Forexample, in FIG. 1, the edit mode runtime extension 106 may be enabledand the second GUI 132 or the third GUI 133 may be provided to thesecond user 112 or the third user 113, respectively, where at least oneof the editing controls 141-143 is enabled.

The method 300 may further include receiving input via the editingcontrol, at 312. For example, in FIG. 1, input may be received via thetext field editing control 141. The method 300 may include modifying oneor more files of the application based on the input, at 314. The filesmay include HTML files, CSS files, XML files, source code files, datafiles, or any combination thereof. For example, in FIG. 1, theapplication files 102 may be modified. To illustrate, a CSS file maydefine a background of a text field to be white. The user may use theediting control to change the background of the text field to blue, and,in response, the definition in the CSS file may be modified.

The method 300 may also include updating the GUI element during theexecution of the application to reflect the input, at 316. Updating theGUI element may include updating a data type, a minimum value, a maximumvalue, a data validation rule, or a layout of the GUI element. Forexample, in FIG. 1, the text field associated with the editing control141 may be updated to reflect the input. To illustrate, the backgroundof the text field may change from white to blue in the executingapplication.

FIG. 4 shows a block diagram of a computing environment 400 including acomputing device 410 operable to support embodiments ofcomputer-implemented methods, computer program products, and systemcomponents according to the present disclosure. For example, thecomputing device 410 or components thereof may include, implement, or beincluded as a component of the system 100 of FIG. 1.

The computing device 410 includes at least one processor 420 and asystem memory 430. For example, the computing device 410 may be adesktop computer, a laptop computer, a tablet computer, a mobile phone,a server, or any other fixed or mobile computing device. Depending onthe configuration and type of computing device, the system memory 430may be volatile (such as random access memory or “RAM”), non-volatile(such as read-only memory or “ROM,” flash memory, and similar memorydevices that maintain stored data even when power is not provided),non-transitory, some combination of the three, or some other memory. Thesystem memory 430 may include an operating system 432, one or moreapplication platforms 434, one or more applications, and program data438. For example, the system memory 430 may include portions of anexecuting application, such as an edit mode runtime extension 435 and anapplication runtime 436. The system memory 430 may also include one ormore application files 437 associated with the application. In anillustrative embodiment, the edit mode runtime extension 435, theapplication runtime 436, and the application files 437 correspond to theedit mode runtime extension 106, the application runtime 104, and theapplication files 102 of FIG. 1, respectively.

The computing device 410 may also have additional features orfunctionality. For example, the computing device 410 may also includeremovable and/or non-removable additional data storage devices such asmagnetic disks, optical disks, tape, and standard-sized or flash memorycards. Such additional storage is illustrated in FIG. 4 by removablestorage 440 and non-removable storage 450. Computer storage media mayinclude volatile and/or non-volatile storage and removable and/ornon-removable media implemented in any technology for storage ofinformation such as computer-readable instructions, data structures,program components or other data. The system memory 430, the removablestorage 440, and the non-removable storage 450 are all examples ofcomputer storage media. The computer storage media includes, but is notlimited to, RAM, ROM, electrically erasable programmable read-onlymemory (EEPROM), flash memory or other memory technology, compact disks(CD), digital versatile disks (DVD) or other optical storage, magneticcassettes, magnetic tape, magnetic disk storage or other magneticstorage devices, or any other medium that can be used to storeinformation and that can be accessed by the computing device 410. Anysuch computer storage media may be part of the computing device 410.

The computing device 410 may also have input device(s) 460, such as akeyboard, mouse, pen, voice input device, touch input device, etc.connected via one or more input interfaces. Output device(s) 470, suchas a display, speakers, printer, etc. may also be included and connectedvia one or more output interfaces. The input device(s) 460 and theoutput device(s) 470 may enable a user 492 to interact with applicationsexecuting at the computing device 410. For example, the output device(s)470 may include a monitor connected to the computing device 410 via anoutput interface, where the output interface is configured to transmitGUI elements generated by the application runtime 436 to the monitor.

The computing device 410 also contains one or more communicationconnections 480 that allow the computing device 410 to communicate withother computing devices 490 over a wired or a wireless network. Forexample, the one or more communication connections 480 may represent aninterface that communicates with the other computing devices 490 via anetwork.

It will be appreciated that not all of the components or devicesillustrated in FIG. 4 or otherwise described in the previous paragraphsare necessary to support embodiments as herein described. For example,the removable storage 440 may be optional.

The illustrations of the embodiments described herein are intended toprovide a general understanding of the structure of the variousembodiments. The illustrations are not intended to serve as a completedescription of all of the elements and features of apparatus and systemsthat utilize the structures or methods described herein. Many otherembodiments may be apparent to those of skill in the art upon reviewingthe disclosure. Other embodiments may be utilized and derived from thedisclosure, such that structural and logical substitutions and changesmay be made without departing from the scope of the disclosure.Accordingly, the disclosure and the figures are to be regarded asillustrative rather than restrictive.

Those of skill would further appreciate that the various illustrativelogical blocks, configurations, modules, and process steps orinstructions described in connection with the embodiments disclosedherein may be implemented as electronic hardware or computer software.Various illustrative components, blocks, configurations, modules, orsteps have been described generally in terms of their functionality.Whether such functionality is implemented as hardware or softwaredepends upon the particular application and design constraints imposedon the overall system. Skilled artisans may implement the describedfunctionality in varying ways for each particular application, but suchimplementation decisions should not be interpreted as causing adeparture from the scope of the present disclosure.

The steps of a method described in connection with the embodimentsdisclosed herein may be embodied directly in hardware, in a softwaremodule executed by a processor, or in a combination of the two. Asoftware module may reside in computer readable media, such as randomaccess memory (RAM), flash memory, read only memory (ROM), registers, ahard disk, a removable disk, a CD-ROM, or any other form of storagemedium known in the art. An exemplary storage medium is coupled to aprocessor such that the processor can read information from, and writeinformation to, the storage medium. In the alternative, the storagemedium may be integral to the processor or the processor and the storagemedium may reside as discrete components in a computing device orcomputer system.

Although specific embodiments have been illustrated and describedherein, it should be appreciated that any subsequent arrangementdesigned to achieve the same or similar purpose may be substituted forthe specific embodiments shown. This disclosure is intended to cover anyand all subsequent adaptations or variations of various embodiments.

The Abstract is provided with the understanding that it will not be usedto interpret or limit the scope or meaning of the claims. In addition,in the foregoing Detailed Description, various features may be groupedtogether or described in a single embodiment for the purpose ofstreamlining the disclosure. This disclosure is not to be interpreted asreflecting an intention that the claimed embodiments require morefeatures than are expressly recited in each claim. Rather, as thefollowing claims reflect, inventive subject matter may be directed toless than all of the features of any of the disclosed embodiments.

The previous description of the embodiments is provided to enable aperson skilled in the art to make or use the embodiments. Variousmodifications to these embodiments will be readily apparent to thoseskilled in the art, and the generic principles defined herein may beapplied to other embodiments without departing from the scope of thedisclosure. Thus, the present disclosure is not intended to be limitedto the embodiments shown herein but is to be accorded the widest scopepossible consistent with the principles and novel features as defined bythe following claims.

What is claimed is:
 1. A method comprising: receiving credentials at acomputing device; evaluating the credentials to determine whether a userassociated with the credentials is authorized to edit an applicationwhile the application is being executed; and upon determining that theuser is authorized, enabling an editing control, wherein the editingcontrol is associated with a graphical user interface (GUI) element ofthe application, and wherein the editing control is operable to updatethe GUI element during execution of the application.
 2. The method ofclaim 1, further comprising receiving input via the editing control. 3.The method of claim 2, further comprising automatically modifying one ormore files of the application based on the input.
 4. The method of claim3, wherein the one or more files of the application include a hypertextmarkup language (HTML) file, a cascading style sheets (CSS) file, anextensible markup language (XML) file, a source code file, a data file,or any combination thereof.
 5. The method of claim 2, further comprisingautomatically updating the GUI element during the execution of theapplication to reflect the input.
 6. The method of claim 5, whereinautomatically updating the GUI element comprises updating a layout ofthe GUI element.
 7. The method of claim 5 wherein automatically updatingthe GUI element comprises updating a data type associated with thefield, updating a minimum value associated with the field, updating amaximum value associated with the field, updating one or more datavalidation rules associated with the field, or any combination thereof.8. The method of claim 1, wherein the credentials are associated with aread-only permission level, a read-write data permission level, or aread-write application permission level.
 9. A computer-readable storagedevice comprising instructions that, when executed by a computer, causethe computer to: receive credentials; evaluate the credentials todetermine whether a user associated with the credentials is authorizedto edit an application while the application is being executed; and upondetermining that the user is authorized, enable an editing controlassociated with a graphical user interface (GUI) element of theapplication, the editing control configured to update the GUI elementduring the execution of the application.
 10. The computer-readablestorage device of claim 9, wherein the credentials comprise a user name,a password, a certificate, or any combination thereof.
 11. Thecomputer-readable storage device of claim 9, wherein the applicationcomprises a web application.
 12. The computer-readable storage device ofclaim 11, wherein the web application includes a form, and wherein theGUI element is a field of the form.
 13. The method of claim 9, whereinthe application includes a runtime layer and an edit mode runtimeextension.
 14. The method of claim 13, wherein the runtime layercomprises a hypertext markup language (HTML) layer, a cascading stylesheets (CSS) layer, or a run mode layer.
 15. The method of claim 14,wherein the application is operable to execute the edit mode runtimeextension in conjunction with execution of the run mode layer withoutcontext switching between the run mode layer and a different mode.
 16. Acomputer system, comprising: a processor; and a memory storinginstructions executable by the processor to: receive credentials;evaluate the credentials to determine whether a user associated with thecredentials is authorized to edit an application while the applicationis being executed; and upon determining that the user is authorized,enable an editing control associated with a graphical user interface(GUI) element of the application, the editing control configured toupdate the GUI element during the execution of the application.
 17. Thecomputer system of claim 16, further comprising an output interfaceconfigured to transmit the GUI element of the application to a displaydevice.
 18. The computer system of claim 16, wherein the instructionsare executable by the processor to disable the editing control when theuser is not authorized to edit the application while the application isbeing executed.
 19. The computer system of claim 18, wherein disablingthe editing control comprises disabling an edit mode runtime extension.20. The computer system of claim 16, wherein the processor: disables allediting controls at the application upon determining that thecredentials are associated with a read-only permission level; enables asubset of editing controls at the application upon determining that thecredentials are associated with a read-write data permission level; andenables all editing controls at the application upon determining thatthe credentials are associated with a read-write application permissionlevel.